home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 August: Tool Chest / Dev.CD Aug 98 TC.toast / Sample Code / Snippets / Networking / TCP / TCPPB.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-07-15  |  9.9 KB  |  408 lines  |  [TEXT/MPS ]
  1. #include    <Devices.h>
  2.  
  3. #include    <MacTCPCommonTypes.h>>
  4. #include    <AddressXlation.h>
  5. #include    <GetMyIPAddr.h>
  6. #include    <TCPPB.h>
  7. #include    <UDPPB.h>
  8.  
  9. #include    <TCP.h>
  10.  
  11. /*
  12. ********************************************************** PBControl Interface Procedures
  13. */
  14.  
  15. #pragma segment TCPPB
  16.  
  17. OSErr    _TCPInit()
  18. {
  19.  
  20.     auto    ParamBlockRec        pb;
  21.     auto    OSErr                osErr;
  22.         
  23.     pb.ioParam.ioCompletion        = 0; 
  24.     pb.ioParam.ioNamePtr        = "\p.ipp"; 
  25.     pb.ioParam.ioPermssn        = fsCurPerm;
  26.     
  27.     osErr = PBOpen(&pb, false);
  28.     if (noErr == osErr) {
  29.         gIPPDriverRefNum        = pb.ioParam.ioRefNum;
  30.     }
  31.         
  32.     return osErr;
  33. }
  34.  
  35. OSErr    _TCPGetIP(pb, ip, netMask, ioCompletion, async)
  36.             struct IPParamBlock        *pb;
  37.             ip_addr                    *ip;
  38.             long                    *netMask;
  39.             ProcPtr                    ioCompletion;
  40.             Boolean                    async;
  41. {
  42.  
  43.     auto    OSErr                    osErr;
  44.     
  45.     pb->ioCompletion                = ioCompletion;
  46.     pb->ioCRefNum                    = gIPPDriverRefNum;
  47.     pb->csCode                        = ipctlGetAddr;
  48.         
  49.     osErr = PBControl((ParmBlkPtr) pb, async);
  50.     if (!async && (noErr == osErr)) {
  51.         *ip                            = pb->ourAddress;
  52.         *netMask                    = pb->ourNetMask;
  53.     }
  54.         
  55.     return osErr;
  56. }
  57.  
  58.  
  59. OSErr    _TCPCreate(pb, stream, rcvBufPtr, rcvBufLen, aNotifyProc, userDataPtr, ioCompletion, async)
  60.             TCPiopb                    *pb;
  61.             StreamPtr                *stream;
  62.             Ptr                        rcvBufPtr;
  63.             long                    rcvBufLen;
  64.             TCPNotifyProc            aNotifyProc;
  65.             Ptr                        userDataPtr;
  66.             TCPIOCompletionProc        ioCompletion;
  67.             Boolean                    async;
  68. {
  69.  
  70.     auto    OSErr                    osErr;
  71.     
  72.     pb->ioCompletion                    = ioCompletion;
  73.     pb->ioCRefNum                        = gIPPDriverRefNum;
  74.     pb->csCode                            = TCPCreate;
  75.     
  76.     pb->csParam.create.rcvBuff            = rcvBufPtr;    
  77.     pb->csParam.create.rcvBuffLen        = rcvBufLen;    
  78.     pb->csParam.create.notifyProc        = aNotifyProc;
  79.     pb->csParam.create.userDataPtr        = userDataPtr;
  80.     
  81.     osErr = PBControl((ParmBlkPtr) pb, async);
  82.     if (!async && (noErr == osErr)) {
  83.         *stream                            = pb->tcpStream;
  84.     }
  85.         
  86.     return osErr;
  87. }
  88.  
  89.  
  90. OSErr _TCPPassiveOpen (pb, stream, remoteIP, remotePort, localIP, localPort, userData, ioCompletion, async)
  91.             TCPiopb                    *pb;
  92.             StreamPtr                stream;
  93.             ip_addr                    *remoteIP; 
  94.             tcp_port                *remotePort; 
  95.             ip_addr                    *localIP; 
  96.             tcp_port                *localPort;
  97.             Ptr                        userData;
  98.             TCPIOCompletionProc        ioCompletion;
  99.             Boolean                    async;
  100. {
  101.  
  102.     auto    OSErr                    osErr;
  103.     auto    short                    index;
  104.     
  105.     pb->ioCompletion                        = ioCompletion;
  106.     pb->ioCRefNum                            = gIPPDriverRefNum;
  107.     pb->csCode                                = TCPPassiveOpen;
  108.     pb->tcpStream                            = stream;
  109.     
  110.     pb->csParam.open.ulpTimeoutValue        = 0;    
  111.     pb->csParam.open.ulpTimeoutAction        = 1;    
  112.     pb->csParam.open.validityFlags            = 0xC0;    
  113.     pb->csParam.open.commandTimeoutValue    = 30;    
  114.     pb->csParam.open.remoteHost                = *remoteIP;    
  115.     pb->csParam.open.remotePort                = *remotePort;    
  116.     pb->csParam.open.localHost                = 0;    
  117.     pb->csParam.open.localPort                = *localPort;    
  118.     pb->csParam.open.tosFlags                = 0;    
  119.     pb->csParam.open.precedence                = 0;    
  120.     pb->csParam.open.dontFrag                = 0;    
  121.     pb->csParam.open.timeToLive                = 0;
  122.     pb->csParam.open.security                = 0;    
  123.     pb->csParam.open.optionCnt                = 0;
  124.     for (index = 0; index < sizeof(pb->csParam.open.options); ++index)    
  125.         pb->csParam.open.options[index]        = 0;    
  126.     pb->csParam.open.userDataPtr            = userData;
  127.     
  128.     osErr = PBControl((ParmBlkPtr) pb, async);
  129.     if (!async && (noErr == osErr)) {
  130.         *remoteIP                            = pb->csParam.open.remoteHost;    
  131.         *remotePort                            = pb->csParam.open.remotePort;    
  132.         *localIP                            = pb->csParam.open.localHost;    
  133.         *localPort                            = pb->csParam.open.localPort;
  134.     }
  135.  
  136.     return osErr;
  137. }
  138.  
  139.  
  140. OSErr _TCPActiveOpen (pb, stream, remoteIP, remotePort, localIP, localPort, userData, ioCompletion, async)
  141.             TCPiopb                    *pb;
  142.             StreamPtr                stream;
  143.             ip_addr                    remoteIP; 
  144.             tcp_port                remotePort; 
  145.             ip_addr                    *localIP; 
  146.             tcp_port                *localPort;
  147.             Ptr                        userData;
  148.             TCPIOCompletionProc        ioCompletion;
  149.             Boolean                    async;
  150. {
  151.  
  152.     auto    OSErr                    osErr;
  153.     auto    short                    index;
  154.     
  155.     pb->ioCompletion                        = ioCompletion;
  156.     pb->ioCRefNum                            = gIPPDriverRefNum;
  157.     pb->csCode                                = TCPActiveOpen;
  158.     pb->tcpStream                            = stream;
  159.     
  160.     pb->csParam.open.ulpTimeoutValue        = 30;
  161.     pb->csParam.open.ulpTimeoutAction        = 1;
  162.     pb->csParam.open.validityFlags            = 0xC0;    
  163. /*    pb->csParam.open.commandTimeoutValue    = 30;  not available with this csCode */
  164.     pb->csParam.open.remoteHost                = remoteIP;    
  165.     pb->csParam.open.remotePort                = remotePort;    
  166.     pb->csParam.open.localHost                = 0;    
  167.     pb->csParam.open.localPort                = *localPort;    
  168.     pb->csParam.open.tosFlags                = 0;    
  169.     pb->csParam.open.precedence                = 0;    
  170.     pb->csParam.open.dontFrag                = 0;    
  171.     pb->csParam.open.timeToLive                = 0;
  172.     pb->csParam.open.security                = 0;    
  173.     pb->csParam.open.optionCnt                = 0;
  174.     for (index = 0; index < sizeof(pb->csParam.open.options); ++index)    
  175.         pb->csParam.open.options[index]        = 0;    
  176.     pb->csParam.open.userDataPtr            = userData;
  177.     
  178.     osErr = PBControl((ParmBlkPtr) pb, async);
  179.     if (!async && (noErr == osErr)) {
  180.         *localIP                            = pb->csParam.open.localHost;    
  181.         *localPort                            = pb->csParam.open.localPort;
  182.     }
  183.  
  184.     return osErr;
  185. }
  186.  
  187.  
  188. OSErr _TCPSend (pb, stream, wdsPtr, userData, ioCompletion, async)
  189.             TCPiopb                    *pb;
  190.             StreamPtr                stream;
  191.             wdsEntry                 *wdsPtr;
  192.             Ptr                        userData;
  193.             TCPIOCompletionProc        ioCompletion;
  194.             Boolean                    async;
  195. {
  196.  
  197.     auto    OSErr                    osErr;
  198.     
  199.     pb->ioCompletion                    = ioCompletion;
  200.     pb->ioCRefNum                        = gIPPDriverRefNum;
  201.     pb->csCode                            = TCPSend;
  202.     pb->tcpStream                        = stream;
  203.     
  204.     pb->csParam.send.ulpTimeoutValue    = 30;    
  205.     pb->csParam.send.ulpTimeoutAction    = 1;    
  206.     pb->csParam.send.validityFlags        = 0xC0;    
  207.     pb->csParam.send.pushFlag            = 0;    
  208.     pb->csParam.send.urgentFlag            = 0;    
  209.     pb->csParam.send.wdsPtr                = (Ptr) wdsPtr;    
  210.     pb->csParam.send.sendFree            = 0;    
  211.     pb->csParam.send.sendLength            = 0;    
  212.     pb->csParam.send.userDataPtr        = userData;
  213.     
  214.     osErr = PBControl((ParmBlkPtr) pb, async);
  215.  
  216.     return osErr;
  217. }
  218.  
  219.  
  220. OSErr _TCPNoCopyRcv (pb, stream, rdsPtr, rdsLength, userData, ioCompletion, async)
  221.             TCPiopb                    *pb;
  222.             StreamPtr                stream;
  223.             rdsEntry                *rdsPtr;
  224.             unsigned short            rdsLength;
  225.             Ptr                        userData;
  226.             TCPIOCompletionProc        ioCompletion;
  227.             Boolean                    async;
  228. {
  229.  
  230.     auto    OSErr                    osErr;
  231.     
  232.     pb->ioCompletion                            = ioCompletion;
  233.     pb->ioCRefNum                                = gIPPDriverRefNum;
  234.     pb->csCode                                    = TCPNoCopyRcv;
  235.     pb->tcpStream                                = stream;
  236.     
  237.     pb->csParam.receive.commandTimeoutValue        = 30;    
  238.     pb->csParam.receive.urgentFlag                = 0;    
  239.     pb->csParam.receive.markFlag                = 0;    
  240.     pb->csParam.receive.rdsPtr                    = (Ptr) rdsPtr;    
  241.     pb->csParam.receive.rdsLength                = rdsLength;    
  242.     pb->csParam.receive.userDataPtr                = userData;
  243.     
  244.     osErr = PBControl((ParmBlkPtr) pb, async);
  245.  
  246.     return osErr;
  247. }
  248.  
  249.  
  250. OSErr _TCPRcv (pb, stream, rcvBufPtr, rcvBufLen, userData, ioCompletion, async)
  251.             TCPiopb                    *pb;
  252.             StreamPtr                stream;
  253.             Ptr                        rcvBufPtr;
  254.             unsigned short            *rcvBufLen;
  255.             Ptr                        userData;
  256.             TCPIOCompletionProc        ioCompletion;
  257.             Boolean                    async;
  258. {
  259.  
  260.     auto    OSErr                    osErr;
  261.     
  262.     pb->ioCompletion                            = ioCompletion;
  263.     pb->ioCRefNum                                = gIPPDriverRefNum;
  264.     pb->csCode                                    = TCPRcv;
  265.     pb->tcpStream                                = stream;
  266.     
  267.     pb->csParam.receive.commandTimeoutValue        = 30;    
  268.     pb->csParam.receive.urgentFlag                = 0;    
  269.     pb->csParam.receive.markFlag                = 0;    
  270.     pb->csParam.receive.rcvBuff                    = rcvBufPtr;    
  271.     pb->csParam.receive.rcvBuffLen                = *rcvBufLen;    
  272.     pb->csParam.receive.userDataPtr                = userData;
  273.     
  274.     osErr = PBControl((ParmBlkPtr) pb, async);
  275.     if (! async)
  276.         *rcvBufLen = pb->csParam.receive.rcvBuffLen;
  277.  
  278.     return osErr;
  279. }
  280.  
  281.  
  282. OSErr _TCPBfrReturn (pb, stream, rdsPtr, userData, ioCompletion, async)
  283.             TCPiopb                    *pb;
  284.             StreamPtr                stream;
  285.             Ptr                        rdsPtr;
  286.             Ptr                        userData;
  287.             TCPIOCompletionProc        ioCompletion;
  288.             Boolean                    async;
  289. {
  290.  
  291.     auto    OSErr                    osErr;
  292.     
  293.     pb->ioCompletion                    = ioCompletion;
  294.     pb->ioCRefNum                        = gIPPDriverRefNum;
  295.     pb->csCode                            = TCPRcvBfrReturn;
  296.     pb->tcpStream                        = stream;
  297.     
  298.     pb->csParam.receive.rdsPtr            = rdsPtr;    
  299.     pb->csParam.receive.userDataPtr        = userData;
  300.     
  301.     osErr = PBControl((ParmBlkPtr) pb, async);
  302.  
  303.     return osErr;
  304. }
  305.  
  306.  
  307. OSErr _TCPClose (pb, stream, userData, ioCompletion, async)
  308.             TCPiopb                    *pb;
  309.             StreamPtr                stream;
  310.             Ptr                        userData;
  311.             TCPIOCompletionProc        ioCompletion;
  312.             Boolean                    async;
  313. {
  314.  
  315.     auto    OSErr                    osErr;
  316.     
  317.     pb->ioCompletion                    = ioCompletion;
  318.     pb->ioCRefNum                        = gIPPDriverRefNum;
  319.     pb->csCode                            = TCPClose;
  320.     pb->tcpStream                        = stream;
  321.     
  322.     pb->csParam.close.ulpTimeoutValue    = 30;    
  323.     pb->csParam.close.ulpTimeoutAction    = 1;    
  324.     pb->csParam.close.validityFlags        = 0xC0;    
  325.     pb->csParam.close.userDataPtr        = userData;
  326.     
  327.     osErr = PBControl((ParmBlkPtr) pb, async);
  328.  
  329.     return osErr;
  330. }
  331.  
  332.  
  333. OSErr _TCPAbort (pb, stream, userData, ioCompletion, async)
  334.             TCPiopb                    *pb;
  335.             StreamPtr                stream;
  336.             Ptr                        userData;
  337.             TCPIOCompletionProc        ioCompletion;
  338.             Boolean                    async;
  339. {
  340.  
  341.     auto    OSErr                    osErr;
  342.     
  343.     pb->ioCompletion                    = ioCompletion;
  344.     pb->ioCRefNum                        = gIPPDriverRefNum;
  345.     pb->csCode                            = TCPAbort;
  346.     pb->tcpStream                        = stream;
  347.     
  348.     pb->csParam.abort.userDataPtr        = userData;
  349.     
  350.     osErr = PBControl((ParmBlkPtr) pb, async);
  351.  
  352.     return osErr;
  353. }
  354.  
  355.  
  356. OSErr _TCPStatus (pb, stream, status, userData, ioCompletion, async)
  357.             TCPiopb                    *pb;
  358.             StreamPtr                stream;
  359.             struct TCPStatusPB        *status;
  360.             Ptr                        userData;
  361.             TCPIOCompletionProc        ioCompletion;
  362.             Boolean                    async;
  363. {
  364.  
  365.     auto    OSErr                    osErr;
  366.     
  367.     pb->ioCompletion                    = ioCompletion;
  368.     pb->ioCRefNum                        = gIPPDriverRefNum;
  369.     pb->csCode                            = TCPStatus;
  370.     pb->tcpStream                        = stream;
  371.     
  372.     pb->csParam.status.userDataPtr        = userData;
  373.     
  374.     osErr = PBControl((ParmBlkPtr) pb, async);
  375.     if (!async && (noErr == osErr)) {
  376.         *status                            = pb->csParam.status;    
  377.     }
  378.  
  379.     return osErr;
  380. }
  381.  
  382.  
  383. OSErr _TCPRelease (pb, stream, rcvBufPtr, rcvBufLen, ioCompletion, async)
  384.             TCPiopb                    *pb;
  385.             StreamPtr                stream;
  386.             Ptr                        *rcvBufPtr;
  387.             long                    *rcvBufLen;
  388.             TCPIOCompletionProc        ioCompletion;
  389.             Boolean                    async;
  390. {
  391.  
  392.     auto    OSErr                    osErr;
  393.     
  394.     pb->ioCompletion                    = ioCompletion;
  395.     pb->ioCRefNum                        = gIPPDriverRefNum;
  396.     pb->csCode                            = TCPRelease;
  397.     pb->tcpStream                        = stream;
  398.     
  399.     osErr = PBControl((ParmBlkPtr) pb, async);
  400.     if (!async && (noErr == osErr)) {
  401.         *rcvBufPtr                        = pb->csParam.create.rcvBuff;    
  402.         *rcvBufLen                        = pb->csParam.create.rcvBuffLen;    
  403.     }
  404.  
  405.     return osErr;
  406. }
  407.  
  408.